# !/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time      :2022/8/10 0010 22:30
# @Author    :jiaxuesong


'''
定义一个类
    定义初始化方法
        获取所有的测试数据绑定为实例属性

    定义一个方法：根据当前用例id，执行依赖的前置用例
        获取用于判断是否有前置用例的关键字：rely, caseid, header, value
        判断是否有前置用例，判断是否第一条用例，判断caseid不为空
            是：根据正则找到请求同/体里面的依赖字段，可以封装一个独立方案进行调用
            执行前置用例获取依赖字段的数据，可以封装一个执行前置用例的方法
            将渠道的依赖字段替换原来的数据
            返回替换好的数据
            否：返回当前的header和body

    定义一个方法：提取需要依赖的请求头/体的字段
        根据正则提取依赖的字段，得到一个列表
        判断得到的列表是否有数据
            是：返回依赖字段
            否：返回个None

    定义一个方法：执行前置用例， 根据准备好的目标字段提取数据：头/体
        准备前置用例需要的数据
        嗲用configHttp进行请求得到结果
        判断请求头里面是否有依赖数据， 有则根据依赖进行替换
        判断请求体里面是否有以来数据，有则根据依赖进行替换
        返回依赖字段
'''
import re
from jsonpath import jsonpath
from hight_interface_test01.common.configHttp import ConfigHttp
# 定义一个类
class PreSolve(object):
#     定义初始化方法
    def __init__(self, testdata):
#         获取所有的测试数据绑定为实例属性
        self.testdata = testdata
        print(self.testdata)
#     定义一个方法：根据当前用例id，执行依赖的前置用例
    def presolve(self, id):
#         获取用于判断是否有前置用例的关键字：rely, caseid, header, value
        rely = self.testdata[int(id) - 1]['rely']
        caseid = self.testdata[int(id) - 1]['caseid']
        header = self.testdata[int(id) - 1]['header']
        value = self.testdata[int(id) - 1]['value']
#         判断是否有前置用例，判断是否第一条用例，判断caseid不为空
        if rely == 'y' and id != '1' and caseid != '':
#             是：根据正则找到请求同/体里面的依赖字段，可以封装一个独立方案进行调用
            post_h = self.get_predata(header)
            post_b = self.get_predata(value)
#             执行前置用例获取依赖字段的数据，可以封装一个执行前置用例的方法
            h, b = self.run_pre(caseid, post_h, post_b)
#             将渠道的依赖字段替换原来的数据
            if h != None:
                header = header.replace('${'+ post_h + '}', h)
            if b != None:
                value = value.replace('${' + post_b + '}', b)
    #             返回替换好的数据
            return header, value
        else:
#             否：返回当前的header和body
            return header, value


        # 定义一个方法：提取需要依赖的请求头 / 体的字段
    def get_predata(self, data):
        # 根据正则提取依赖的字段，得到一个列表
        res = re.findall(r"\$\{(.*?)\}" , data)
        # 判断得到的列表是否有数据
        if len(res) != 0:
        # 是：返回依赖字段
            res_data = res[0]
        # 否：返回个None
        else:
            res_data = None
        return res_data

    # 定义一个方法：执行前置用例， 根据准备好的目标字段提取数据：头/体
    def run_pre(self, caseid, goal_h= None, goal_b = None):
    #     准备前置用例需要的数据
        preUrl = self.testdata[int(caseid) - 1]['interfaceUrl']
        preMethod = self.testdata[int(caseid) - 1]['method']
        preValue = self.testdata[int(caseid) - 1]['value']
        preHeader = self.testdata[int(caseid) - 1]['header']
    #     嗲用configHttp进行请求得到结果
        ch = ConfigHttp(preUrl, preMethod, eval(preValue), eval(preHeader))
        res = ch.get_method()
    #     判断请求头里面是否有依赖数据， 有则根据依赖进行替换
        if goal_h != None:
            goal_h = res.headers[goal_h]
    #     判断请求体里面是否有以来数据，有则根据依赖进行替换
        if goal_b != None:
            goal_b = jsonpath(res.json(), "$.." + goal_b)[0]
    #     返回依赖字段
        return goal_h, goal_b

if __name__ == '__main__':
    from hight_interface_test01.common.readExcle import ReadExcle
    res = ReadExcle().read()
    rea = PreSolve(res)
    # re.presolve(1)
    # print(rea.get_predata("{'name':'${username}','link':'www.baidu.com'}"))
    # print(rea.run_pre("1", "Set-Cookie", "username"))
    print(rea.presolve(3))